package yf.mall.service.impl;

import org.springframework.context.annotation.Lazy;
import yf.mall.common.Const;
import yf.mall.dao.AccountDao;
import yf.mall.dao.LevelRecordDao;
import yf.mall.dao.UserDao;
import yf.mall.entity.LevelRecordEntity;
import yf.mall.entity.UserEntity;
import com.yf.service.impl.BaseServiceImpl;
import yf.mall.enums.LevelEnum;
import yf.mall.enums.LevelTypeEnum;
import com.yf.response.RRException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

import yf.mall.dao.LevelDao;
import yf.mall.entity.LevelEntity;
import yf.mall.service.LevelRecordService;
import yf.mall.service.LevelService;
import org.springframework.transaction.annotation.Transactional;
import yf.mall.service.UserService;
import yf.mall.vo.UserLevelVo;
import yf.mall.vo.UserVo;

import javax.annotation.Resource;

/**
 * 级别Service实现类
 *
 * 
 *
 * @date Thu Jul 11 12:00:51 CST 2019
 */
@Service
public class LevelServiceImpl extends BaseServiceImpl<LevelEntity> implements LevelService {

    private LevelDao levelDao;

    @Autowired
    private AccountDao accountDao;


    @Autowired
    public void setDao(LevelDao levelDao) {
        this.levelDao = levelDao;
        super.setBaseDao(levelDao);
    }


    /**内部方法**/


    /**
     * 外部方法实现
     **/

    @Override
    public List<LevelEntity> findLowLevel(Long userId) {
        List<LevelEntity> levelEntities = levelDao.queryList(null);
        UserEntity userEntity = userDao.get(userId);
        LevelEntity levelEntity = levelDao.get(userEntity.getLevelId());
        if (levelEntity.getLv() < 45) {
            levelEntities = levelEntities.stream().filter(level ->
                    level.getLv() >= levelEntity.getLv() && level.getType().equals(LevelTypeEnum.PUB.getIndex())
            ).collect(Collectors.toList());
        } else {
            levelEntities = levelEntities.stream().filter(level ->
                    level.getLv() > levelEntity.getLv() && level.getType().equals(LevelTypeEnum.PUB.getIndex())
            ).collect(Collectors.toList());
        }
        return levelEntities;
    }

    @Resource
    @Lazy
    private UserService userService;

    @Resource
    @Lazy
    private LevelRecordService recordService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void changeLevel(Long userId, Long oldLevelId, Long toLevelId, String orderNo, String remark) {
        //更新用户
        UserEntity user = userDao.get(userId);
        user.setLevelId(toLevelId);
        //升级时间
        user.setLvTime(new Date());
        userService.update(user);
        //保存记录
        recordService.addRecord(userId, toLevelId, oldLevelId, orderNo, remark);
    }


//    @Override
//    public void autoLevel(Long userId, Long leveId, String orderNo, String remark) {
//        //粉钻以下 直接三个就可以升级
//        LevelEntity level = levelDao.get(leveId);
//        UserEntity user = userDao.get(userId);
//        UserEntity top = userDao.get(user.getPid());
//        if (user.getPid().equals(Const.ADMIN_ID)) { //上级是公司直接跳过
//            return;
//        }
//        //升级粉钻以下 查看直接上级
//        if (level.getLv() > LevelEnum.FZ.lv) {
//            Integer vipCount = 0; //vip及以上
//            Integer bzCount = 0; //白钻及以上
//            List<UserEntity> childList = userService.findByPid(top.getId());
//            for (UserEntity child :
//                    childList) {
//                if (LevelEnum.getLv(child.getLevelId()) <= LevelEnum.VIP.lv) {//VIP及以上
//                    vipCount++;
//                }
//                if (LevelEnum.getLv(child.getLevelId()) <= LevelEnum.BZ.lv) { //白钻及以上
//                    bzCount++;
//                }
//            }
//            if (bzCount >= 3) {//白钻及以上升级粉钻
//                if (upLevel(top.getId(), LevelEnum.FZ.levelId, orderNo, remark)) { //成功升级粉钻
//                    autoLevel(top.getId(), LevelEnum.FZ.levelId, orderNo, top.getName() + top.getCode() + LevelEnum.FZ.name);
//                }
//            } else if (vipCount >= 3) { //VIP 升级白钻
//                if (upLevel(top.getId(), LevelEnum.BZ.levelId, orderNo, remark)) {
//                    autoLevel(top.getId(), LevelEnum.BZ.levelId, orderNo, top.getName() + top.getCode() + LevelEnum.BZ.name);
//                }
//            }
//        } else { //升级粉钻及以上 开始递归查看上面哪些能升级 暂时直接下级 TODO 整条线
//            Integer fzCount = 0; //粉钻及以上
//            Integer lzCount = 0; //蓝钻及以上
//            List<UserEntity> childList = userService.findByPid(top.getId());
//            for (UserEntity child :
//                    childList) {
//                if (LevelEnum.getLv(child.getLevelId()) <= LevelEnum.FZ.lv) {//粉钻及以上
//                    fzCount++;
//                }
//                if (LevelEnum.getLv(child.getLevelId()) <= LevelEnum.LZ.lv) { //蓝钻及以上
//                    lzCount++;
//                }
//                if (lzCount >= 3) { //升级红钻
//                   if( upLevel(top.getId(),LevelEnum.HZ.levelId, orderNo,remark)){
//                       autoLevel(top.getId(),LevelEnum.HZ.levelId, orderNo,remark);
//                   }
//                } else if (fzCount >= 3) { //升级蓝钻
//                    if(upLevel(top.getId(),LevelEnum.LZ.levelId, orderNo,remark)){
//                        autoLevel(top.getId(),LevelEnum.LZ.levelId, orderNo,remark);
//                    }
//                }
//
//            }
//        }
//    }


    //是否可以升级蓝钻
//    private Long emit(UserLevelVo levelVo) {
//        Map<Long, Integer> map = levelVo.getMap();
//        //蓝钻+红钻大于3 可以升级红钻
//        if (map.get(LevelEnum.HZ.levelId) + map.get(LevelEnum.LZ.levelId) >= 3) {
//            return LevelEnum.HZ.levelId;
//        }
//        //粉钻以及以上的级别大于等于3
//        if ((map.get(LevelEnum.HZ.levelId) + map.get(LevelEnum.LZ.levelId) + map.get(LevelEnum.FZ.levelId)) >= 3) {
//            return LevelEnum.LZ.levelId;
//        }
//        return -1L;
//    }

    //给某人升级
//    public Boolean upLevel(Long userId, Long levelId, String orderNo, String remark) {
//        UserEntity user = userDao.get(userId);
//        LevelEntity level = levelDao.get(user.getLevelId());
//        LevelEntity toLevel = levelDao.get(levelId);
//        if (level.getLv() > toLevel.getLv()) { //级别小才升级
//            changeLevel(userId, level.getId(), toLevel.getId(), orderNo, remark);
//            return true;
//        }
//        return false;
//    }

//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public LevelEntity changeLevel(Long userId, Long toUserId, Long levelId) {
//        UserEntity userEntity = userDao.get(userId);
//        UserEntity toUser = userDao.get(toUserId);
//        if (!toUser.getPid().equals(userEntity.getId())) {
//            throw new RRException("无权限操作!");
//        }
//        //不可以操作内部级别用户
//        if (levelDao.get(toUser.getLevelId()).getType().equals(LevelTypeEnum.PRI.getIndex())) {
//            throw new RRException("无权限对此级别用户操作!");
//        }
//        LevelEntity toLevel = levelDao.get(levelId);
//        if (!toLevel.getType().equals(LevelTypeEnum.PUB.getIndex())) {
//            throw new RRException("非法操作级别");
//        }
////        this.userService.updateExp(toUserId, toLevel);
//        LevelEntity level = levelDao.get(userEntity.getLevelId());
//        //大区以上不允许升级同等级以上的级别
//        if (level.getLv() <= 5) {
//            if (level.getLv() >= toLevel.getLv()) {
//                throw new RRException("非法操作级别!");
//            }
//        } else {
//            if (level.getLv() > toLevel.getLv()) {
//                throw new RRException("非法操作级别!");
//            }
//        }
//        toUser.setLevelId(levelId);
//
//        userDao.update(toUser);
//        return toLevel;
//    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public List<LevelEntity> findlist() {
        List<LevelEntity> levelList = this.levelDao.findLevelList();
        return levelList;
    }

    @Autowired
    private LevelRecordDao levelRecordDao;

//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public LevelEntity changeLevelByExp(Long userId, BigDecimal exp) {
//        //比较当前人的经验值跟自己的级别是否同步 如果比自己的级别该有的少 则补上
//        LevelEntity levelEntity = levelDao.findByUserId(userId);
//        LevelEntity temLv = findByExp(exp);
//        UserEntity userEntity = userDao.get(userId);
//        if (temLv.getType() == LevelTypeEnum.PUB.getIndex()) {
//            //需要升级
//            userEntity.setLevelId(temLv.getId());
//        } else {
//            LevelEntity max = levelDao.findBaseMax();
//            //如果要往高等级别升 且本身级别比最低级别低  只能升级到最低可升级级别
//            if (levelEntity.getLv() > max.getLv()) {
//                //设置成最高可以升级级别
//                userEntity.setLevelId(max.getId());
//            }
//        }
//        LevelEntity toLv = levelDao.get(userEntity.getLevelId());
//        if (!levelEntity.getLv().equals(toLv.getLv())) {
//            LevelRecordEntity lvRecord = new LevelRecordEntity();
//            lvRecord.setUserId(userEntity.getId());
//            lvRecord.setNowLevel(toLv.getName());
//            lvRecord.setOldLevel(levelEntity.getName());
//            lvRecord.setTime(new Date());
//            levelRecordDao.save(lvRecord);
//        }
//        userDao.update(userEntity);
//        return levelEntity;
//    }

    @Override
    public LevelEntity findByUserId(Long userId) {
        return levelDao.findByUserId(userId);
    }

//    @Override
//    public LevelEntity findByExp(BigDecimal exp) {
//        LevelEntity levelEntity = levelDao.findBase();
//        List<LevelEntity> levelEntities = levelDao.findLevelList();
//        for (LevelEntity level : levelEntities) {
//            if (exp.compareTo(level.getAmount()) >= 0) {
//                levelEntity = level;
//            }
//        }
//        return levelEntity;
//    }

    @Autowired
    private UserDao userDao;
}
